{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lecture 7: Introduction to Probability Theory (Part IV)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objectives\n",
    "\n",
    "+ Introduce pseudo-random number generators (PRNG).\n",
    "+ Demonstrate how we can sample from the uniform distribution using PRNGs.\n",
    "+ Demonstrate how we can sample from the Bernoulli using uniform samples.\n",
    "+ Demonstrate how we can sample from arbitrary discrete distributions using uniform samples.\n",
    "+ Demonstrate the central limit theorem and the natural rise of the Gaussian distribution.\n",
    "+ Demonstrate how we can sample from univariate continuous distributions using uniform samples (inverse transform sampling, rejection sampling)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Readings\n",
    "\n",
    "+ These notes.\n",
    "+ [Middlesquare algorithm](https://en.wikipedia.org/wiki/Middle-square_method).\n",
    "+ [Linear congruential generator](https://en.wikipedia.org/wiki/Linear_congruential_generator).\n",
    "+ [Empirical CDF](https://en.wikipedia.org/wiki/Empirical_distribution_function).\n",
    "+ [The central limit theorem](https://en.wikipedia.org/wiki/Central_limit_theorem).\n",
    "+ [Characteristic functions](https://en.wikipedia.org/wiki/Characteristic_function_(probability_theory)).\n",
    "+ [Inversion transform sampling](https://en.wikipedia.org/wiki/Inverse_transform_sampling).\n",
    "+ [Rejection sampling](https://en.wikipedia.org/wiki/Rejection_sampling)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "sns.set_context('talk')\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pseudo-random number generators (PRNG)\n",
    "\n",
    "Random number generation is the backbone of Bayesian inference.\n",
    "Computers are deterministic.\n",
    "So, how can they generate random numbers?\n",
    "Well they cannot!\n",
    "But they can produce sequence of numbers that look like random numbers!\n",
    "These \"fake\" random number generators are called Pseudo-random number generators (PRNG).\n",
    "They are used to generate random numbers between zero and a maximum integer, say $m$.\n",
    "As we will argue later this is sufficient to generate pretty much any random variable you want.\n",
    "\n",
    "### The middlesquare algorithm (Von Neumann)\n",
    "\n",
    "The [middlesquare algorithm](https://en.wikipedia.org/wiki/Middle-square_method) is the simplest PRNG.\n",
    "\n",
    "1. Take a number and square it.\n",
    "2. Pad the result with zeros to get to the desired number of digits.\n",
    "3. Take the middle digits of the resulting number.\n",
    "4. Repeat.\n",
    "\n",
    "Here is an implementation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def middlesquare(s, digits=4):\n",
    "    \"\"\"\n",
    "    :param s:      The initial seed.\n",
    "    :param digits: How many digits do you want.\n",
    "    \"\"\"\n",
    "    # Square the number\n",
    "    s2 = s ** 2\n",
    "    # Turn the resulting number into a string padding with zeros to get to the desired number of digits\n",
    "    s2_str = str(s2).zfill(2*digits)\n",
    "    # Keep only the middle\n",
    "    middle_str = s2_str[int(np.floor(digits/2)):][:-int(np.floor(digits/2))]\n",
    "    return int(middle_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's draw some random numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5227\n",
      "3215\n",
      "3362\n",
      "3030\n",
      "1809\n",
      "2724\n",
      "4201\n",
      "6484\n",
      "422\n",
      "1780\n",
      "1684\n",
      "8358\n",
      "8561\n",
      "2907\n",
      "4506\n",
      "3040\n",
      "2416\n",
      "8370\n",
      "569\n",
      "3237\n"
     ]
    }
   ],
   "source": [
    "seed = 1234\n",
    "s = seed\n",
    "for _ in range(20):\n",
    "    s = middlesquare(s, digits=4)\n",
    "    print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unfortunately, the middlesquare algorithms results in periodic sequences with very small period. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2916\n",
      "5030\n",
      "3009\n",
      "540\n",
      "2916\n",
      "5030\n",
      "3009\n",
      "540\n",
      "2916\n",
      "5030\n",
      "3009\n",
      "540\n",
      "2916\n",
      "5030\n",
      "3009\n",
      "540\n",
      "2916\n",
      "5030\n",
      "3009\n",
      "540\n"
     ]
    }
   ],
   "source": [
    "seed = 540\n",
    "s = seed\n",
    "for _ in range(20):\n",
    "    s = middlesquare(s, digits=4)\n",
    "    print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Linear congruential generator (LCG)\n",
    "The [linear congruential generator](https://en.wikipedia.org/wiki/Linear_congruential_generator) works as follows. You pick three big integers $a$, $b$ and $m$.\n",
    "Pick a seed $x_0$.\n",
    "Then iterate:\n",
    "$$\n",
    "x_{i+1} = (a x_i + b)\\mod m\n",
    "$$\n",
    "\n",
    "Here is a simple implementation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lcg(x, a=123456, b=978564, m=6012119):\n",
    "    \"\"\"\n",
    "    :param x: The previous number in the sequence.\n",
    "    :param a: A big integer.\n",
    "    :param b: Another big integer.\n",
    "    :param m: Another big integer.\n",
    "    \"\"\"\n",
    "    return (a * x + b) % m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3020293\n",
      "2650792\n",
      "5494308\n",
      "965075\n",
      "3115541\n",
      "1883116\n",
      "317849\n",
      "243995\n",
      "2909094\n",
      "134725\n",
      "4067010\n",
      "1658958\n",
      "451558\n",
      "4155644\n",
      "2001482\n",
      "3861575\n",
      "4605659\n",
      "1061643\n",
      "2982572\n",
      "5159241\n"
     ]
    }
   ],
   "source": [
    "# Let's draw some random numbers:\n",
    "seed = 1234\n",
    "s = seed\n",
    "for _ in range(20):\n",
    "    s = lcg(s)\n",
    "    print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The good thing about LCG is that you can prove a lot of stuff about it using group theory and that you know that the maximum possible number is $m-1$.\n",
    "That is, you know that it gives you numbers between 0 and $m-1$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mersenne Twister PRNG\n",
    "Numpy uses the [Mersenne Twister](https://en.wikipedia.org/wiki/Mersenne_Twister) to generate random numbers.\n",
    "Its details are more complicated than LCG, but it is still initialized by an integer seed.\n",
    "You can test it as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1396132\n",
      "2993577\n",
      "1134974\n",
      "5664101\n",
      "3555874\n"
     ]
    }
   ],
   "source": [
    "# set the seed\n",
    "np.random.seed(12345)\n",
    "# print 5 integers from 0 to 6012119\n",
    "for _ in range(5):\n",
    "    print(np.random.randint(0, 6012119))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5290753\n",
      "4246897\n",
      "3579195\n",
      "3692649\n",
      "3755099\n"
     ]
    }
   ],
   "source": [
    "# see what the seed does - Here is what happens if you rerun the code above:\n",
    "for _ in range(5):\n",
    "    print(np.random.randint(0, 6012119))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1396132\n",
      "2993577\n",
      "1134974\n",
      "5664101\n",
      "3555874\n"
     ]
    }
   ],
   "source": [
    "# And here is what happens if you reset the seed to its original value and rerun the code\n",
    "np.random.seed(12345)\n",
    "for _ in range(5):\n",
    "    print(np.random.randint(0, 6012119))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, resetting the seed gives you the same sequence. In your numerical simulations you should always set the seed by hand in order to ensure the reproducibility of your work."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sampling from the uniform distribution\n",
    "\n",
    "If we have a PRNG that samples between zero and a big integer, say $m$, we can create a generator that samples from the uniform distribution.\n",
    "If $d$ is the sample from the PRNG, then\n",
    "$$\n",
    "x = \\frac{d}{m},\n",
    "$$\n",
    "is approximately uniformly distributed.\n",
    "Let's experiment with this idea."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LCG Uniform Samples:\n",
      "0.27292124457283695\n",
      "0.9279352255003602\n",
      "0.3339646138075444\n",
      "0.09812746554085174\n",
      "0.5871510527319902\n",
      "\n",
      "MT Uniform Samples:\n",
      "0.011933396527913037\n",
      "0.8868237638010824\n",
      "0.5074856302744507\n",
      "0.5300725085448242\n",
      "0.5373225313737137\n"
     ]
    }
   ],
   "source": [
    "# The maximum integer\n",
    "m = 6012119\n",
    "\n",
    "# First a uniform random generator based on lcg\n",
    "lcg_seed = 123456 # A seed of lcg\n",
    "lcg_state = lcg_seed # Internal state of lcg\n",
    "def unif_lcg():\n",
    "    \"\"\"\n",
    "    Samples from the uniform using LCG.\n",
    "    \"\"\"\n",
    "    global lcg_state\n",
    "    lcg_state = lcg(lcg_state)\n",
    "    return lcg_state / (1. * m) # The 1. in the denominator ensures\n",
    "                                # that the division is done in floating point arithmetic\n",
    "print('LCG Uniform Samples:')\n",
    "for _ in range(5):\n",
    "    print(unif_lcg())\n",
    "\n",
    "# And let's also do it with Mersenne Twister from numpy\n",
    "np.random.seed(123456)\n",
    "def unif_mt():\n",
    "    \"\"\"\n",
    "    Samples from the uniform using the MT.\n",
    "    \"\"\"\n",
    "    return np.random.randint(0, m) / (1. * m)\n",
    "print('\\nMT Uniform Samples:')\n",
    "for _ in range(5):\n",
    "    print(unif_mt())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Which one of the two is better? There are many statistical tests that we would like our uniform random number generator to go through. First (and most importantly) the empirical histograms of the generated numbers should be uniform. Let's test this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1a23a9bfd0>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 900x600 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# How many numbers to sample:\n",
    "N = 100\n",
    "lcg_X = [unif_lcg() for _ in range(N)]\n",
    "mt_X = [unif_mt() for _ in range(N)]\n",
    "# Plot the histograms\n",
    "fig, ax = plt.subplots(dpi=150)\n",
    "ax.hist(lcg_X, density=True, alpha=0.5, label='LGC_unif')\n",
    "ax.hist(mt_X, density=True, alpha=0.5, label='MT_unif')\n",
    "ax.set_xlabel('$x$')\n",
    "ax.set_ylabel('$p(x)$')\n",
    "plt.legend(loc='best')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This was a rough visual test.\n",
    "We can do better.\n",
    "We can compare the [empirical CDF](https://en.wikipedia.org/wiki/Empirical_distribution_function) of each one of these algorithms with the ideal CDF, i.e., that of a real uniform.\n",
    "But what is the empirical CDF of a bunch of samples $x_{1:N}$?\n",
    "It is defined as follows:\n",
    "$$\n",
    "\\hat{F}_N(x) = \\frac{\\text{number of elements in sample}\\;\\le x}{N} = \\frac{1}{N}\\sum_{n=1}^N 1_{(-\\infty, x_i]}(x).\n",
    "$$\n",
    "Let's implement this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ecdf(x):\n",
    "    \"\"\"\n",
    "    The empirical distribution function of scalar samples.\n",
    "    \n",
    "    From: https://stackoverflow.com/questions/15792552/numpy-scipy-equivalent-of-r-ecdfxx-function\n",
    "    \"\"\"\n",
    "    xs = np.sort(x)\n",
    "    ys = np.arange(1, len(xs)+1)/float(len(xs))\n",
    "    return xs, ys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's plot the empirical CDF of each of the samples and plot it against $F(x) = x$ (the true CDF of the uniform)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 900x600 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(dpi=150)\n",
    "ax.plot(*ecdf(lcg_X), label='LCG')\n",
    "ax.plot(*ecdf(mt_X), label='MT')\n",
    "ax.plot(np.linspace(0, 1), np.linspace(0, 1), label='Uniform')\n",
    "ax.set_xlabel('$x$')\n",
    "ax.set_ylabel('$\\hat{F}_N(x)$')\n",
    "plt.legend(loc='best');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is still visual. The [Kolmogorov-Smirnov test](https://en.wikipedia.org/wiki/Kolmogorov%E2%80%93Smirnov_test) summarizes calculate a distance between the empirical distribution and the ideal one.\n",
    "It is defined as follows:\n",
    "$$\n",
    "D_N = \\sup_x |F(x) - \\hat{F}_N(x)|,\n",
    "$$\n",
    "where (if you don't know what it is) you can think of the supremum ($\\sup$) as just the maximum.\n",
    "In other words, $D_N$ is the maximum absolute difference between $F(x)$ and $\\hat{F}_N(x)$.\n",
    "Let's see what we get for LCG and MT compared to the uniform:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "KS statistic for LCG vs uniform: 0.13\n",
      "KS statistic for MT vs uniform: 0.06\n"
     ]
    }
   ],
   "source": [
    "import scipy.stats as st\n",
    "D_lcg, p_val_lcg = st.kstest(lcg_X, 'uniform')\n",
    "D_mt, p_val_mt = st.kstest(mt_X, 'uniform')\n",
    "print('KS statistic for LCG vs uniform: {0:1.2f}'.format(D_lcg))\n",
    "print('KS statistic for MT vs uniform: {0:1.2f}'.format(D_mt))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question\n",
    "+ Hmm, we probably need to increase the number of samples to observe this statistic better. Increase $N$ from 100 to $1,000$ and then to $10,000$. How do the distributions look like now?\n",
    "\n",
    "+ A second thing that we would like to test is whether or not consecutive numbers are all independent (Idependent identically distributed). Unfortunately, we need more theory than we know to do this.\n",
    "\n",
    "+ For future reference, note that you should not really use ``unif_mt`` to generate uniform random numbers. Numpy already implements this in ``numpy.random.rand``. We provide an example right below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.15584706 0.86260898 0.6830463  0.0857089  0.56610253 0.14982485\n",
      " 0.47745445 0.84893827 0.14014442 0.32955081]\n"
     ]
    }
   ],
   "source": [
    "# Generate some random numbers with numpy's unif_mt:\n",
    "X = np.random.rand(10)\n",
    "print(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example: Sampling the Bernoulli distribution\n",
    "The Bernoulli distribution arises from a binary random variable representing the outcome of an experiment with a given probability of success.\n",
    "Let us encode success with 1 and failure with 0.\n",
    "Then, we say that the random variable\n",
    "$$\n",
    "X\\sim \\operatorname{Bernoulli}(\\theta),\n",
    "$$\n",
    "is a Bernoulli random variable with parameter $\\theta$ if:\n",
    "$$\n",
    "X = \\begin{cases}\n",
    "1,\\;\\text{with probability}\\;\\theta,\\\\\n",
    "0,\\;\\text{otherwise}.\n",
    "\\end{cases}\n",
    "$$\n",
    "Another way to write the same thing is through the probability density function of $X$:\n",
    "$$\n",
    "p(x) = \\theta \\delta(x-1) + (1-\\theta)\\delta(x),\n",
    "$$\n",
    "where we used Dirac's delta to talk about point masses.\n",
    "To sample from it, we do the following steps:\n",
    "\n",
    "+ Sample a uniform number $u$ (i.e., a number of $\\mathcal{U}([0,1])$).\n",
    "\n",
    "+ If $u\\le \\theta$, then set $x = 1$.\n",
    "\n",
    "+ Otherwise, set $x = 0$.\n",
    "\n",
    "Let's see if this process does indeed produce the desired result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "0\n",
      "1\n",
      "0\n",
      "0\n",
      "1\n",
      "0\n",
      "0\n",
      "0\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "def sample_bernoulli(theta):\n",
    "    \"\"\"\n",
    "    Samples from the Bernoulli.\n",
    "    \"\"\"\n",
    "    u = np.random.rand()\n",
    "    if u <= theta:\n",
    "        return 1\n",
    "    return 0\n",
    "\n",
    "for _ in range(10):\n",
    "    print(sample_bernoulli(0.5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, '$p(x)$')"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Let's do a histogram like before\n",
    "N = 1000\n",
    "X = [sample_bernoulli(0.3) for _ in range(N)]\n",
    "fig, ax = plt.subplots()\n",
    "ax.hist(X, alpha=0.5)\n",
    "ax.set_xlabel('$x$')\n",
    "ax.set_ylabel('$p(x)$')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok, it looks fine. About $\\theta N$ samples went to 1 and $(1-\\theta)N$ samples went to 0.\n",
    "\n",
    "Of course, we have already seen that this is implemented in scipy.stats.\n",
    "Here is a quick reminder of that code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 1, 1, 1, 1, 0, 1, 0, 0])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = st.bernoulli(0.3)\n",
    "X.rvs(size=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sampling discrete distributions\n",
    "Consider a generic discrete random variable $X$ taking $K$ different values.\n",
    "Without loss of generality, you may assume that these values are integers $\\{0, 1,2,\\dots,K-1\\}$ (they are just the labels of the discrete objects anyway).\n",
    "Let us assume that\n",
    "$$\n",
    "p(X=k) = p_k,\n",
    "$$\n",
    "where, of course, we must have:\n",
    "$$\n",
    "p_k \\ge 0,\n",
    "$$\n",
    "and\n",
    "$$\n",
    "\\sum_{k=0}^{K-1} p_k = 1.\n",
    "$$\n",
    "Remember, that an succinct way to write this is using the Dirac delta:\n",
    "$$\n",
    "p(x) = \\sum_{k=0}^{K-1}p_k\\delta(x-k).\n",
    "$$\n",
    "In any case, here is how you sample from such a distribution:\n",
    "\n",
    "+ Draw a uniform sample $u$.\n",
    "+ Find the index $j\\in\\{0,1,\\dots,K-1\\}$ such that:\n",
    "$$\n",
    "\\sum_{k=0}^{j-1}p_k \\le u < \\sum_{k=0}^jp_k.\n",
    "$$\n",
    "+ Then, your sample is $j$.\n",
    "\n",
    "Let's code it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sample_discrete(p):\n",
    "    \"\"\"\n",
    "    Sample from a discrete probability density.\n",
    "    \n",
    "    :param p: An array specifying the probability of each possible state.\n",
    "              The number of states ``m=len(p)``.\n",
    "    :returns: A random integer.\n",
    "    \n",
    "    (btw this is how you document a python function)\n",
    "    \"\"\"\n",
    "    K = len(p)\n",
    "    u = np.random.rand()\n",
    "    c = 0.\n",
    "    for j in range(K):\n",
    "        c += p[j]\n",
    "        if u <= c:\n",
    "            return j"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, '$p(x)$')"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Let's test it with a four-state discrete random variable with probabilities\n",
    "p = [0.2, 0.3, 0.4, 0.1]\n",
    "# Let's take 1,000 samples\n",
    "N = 1000\n",
    "X = [sample_discrete(p) for _ in range(N)]\n",
    "# and do the empirical histrogram\n",
    "fig, ax = plt.subplots()\n",
    "ax.hist(X, alpha=0.5)\n",
    "ax.set_xlabel('$x$')\n",
    "ax.set_ylabel('$p(x)$')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, numpy already implements this functionality. Here is how to do the same thing numpy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1a246f18d0>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "X_np = np.random.choice(np.arange(4), # The objects that you want to sample (here integers, 0,1,2,3)\n",
    "                        p=p,          # The probability of sampling each object\n",
    "                        size=N        # How many samples you want  \n",
    "                       )\n",
    "# Let's compare the two histograms\n",
    "fig, ax = plt.subplots()\n",
    "ax.hist(X, alpha=0.5, label='Our implementation')\n",
    "ax.hist(X_np, alpha=0.5, label='Numpy implementation')\n",
    "ax.set_xlabel('$x$')\n",
    "ax.set_ylabel('$p(x)$')\n",
    "plt.legend(loc='best')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And it is also possible to do it using a Categorical random variable from scipy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 3, 2, 2, 3, 0, 2, 1, 2, 2, 1, 1, 0, 1, 2, 0, 3, 2, 2, 2, 2,\n",
       "       0, 3, 3, 2, 0, 2, 0, 2, 1, 1, 0, 2, 2, 2, 2, 1, 2, 2, 0, 2, 2, 2,\n",
       "       1, 2, 2, 2, 2, 1, 3, 0, 1, 0, 3, 3, 1, 1, 2, 2, 3, 0, 0, 3, 0, 0,\n",
       "       2, 2, 3, 1, 2, 1, 2, 2, 2, 1, 3, 1, 2, 2, 0, 2, 0, 2, 1, 1, 0, 0,\n",
       "       1, 2, 2, 2, 0, 2, 2, 2, 3, 2, 1, 0])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_st = st.rv_discrete(values=(np.arange(4), p))\n",
    "X_st.rvs(size=100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example: The Binomial distribution for large $N$\n",
    "\n",
    "The Binomial distribution gives you the number of successes in $N$ tries of a random experiment with probability of success $\\theta$.\n",
    "We write:\n",
    "$$\n",
    "X\\sim B(N,\\theta).\n",
    "$$\n",
    "You can easily simulate it (excersize) by noticing that:\n",
    "$$\n",
    "X = \\sum_{i=1}^N X_i,\n",
    "$$\n",
    "where\n",
    "$$\n",
    "X_i \\sim B(\\theta),\n",
    "$$\n",
    "are indepdent Bernoulli trials.\n",
    "We can also show that:\n",
    "$$\n",
    "p(X=k) = \\left(\\begin{array}{c}N\\\\ k\\end{array}\\right)\\theta^k(1-\\theta)^{N-k}.\n",
    "$$\n",
    "Let's plot this distribution for various $N$'s.\n",
    "We will use the built-in ``scipy.stats`` functionality for this one.\n",
    "For your future reference, you can find it [here](https://docs.scipy.org/doc/scipy/reference/stats.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import scipy.stats as st\n",
    "\n",
    "def plot_binom_pdf(N, theta):\n",
    "    k = np.arange(N) + 1. # From 1 to N\n",
    "    p_k = st.binom(N, theta).pmf(k) # pmf is short for probability mass function\n",
    "                                    # which is the right terminology for a discrete variable\n",
    "                                    # (i.e., we use 'mass' instead of 'density')\n",
    "    fig, ax = plt.subplots()\n",
    "    ax.plot(k, p_k, 'o', color='b')\n",
    "    ax.vlines(k, 0, p_k, colors='b', lw=5, alpha=0.5)\n",
    "    ax.set_xlabel('$x$')\n",
    "    ax.set_ylabel('$p(x)$')\n",
    "    ax.set_title(r'$\\mathcal{B}(N=%d, \\theta=%.2f)$' % (N, theta)) # the 'r' is required to render\n",
    "                                                                   # '\\' character correctly\n",
    "    \n",
    "plot_binom_pdf(4, 0.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok, now let's play with $N$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEvCAYAAAAQB1WgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3de5hcVZnv8e+PTkvSZEwnEcxw1IOACiTMAHHmgIOCyogil4AJjhfAM4JXhCFmUI8QpFEcHWgRnHFGxCHHy1GIJJgxeCcOKip4Y6AVkasIAUw6waQTAp33/LF2kUqlqruru7pqpev3eZ79bGqttfd6d5HUm7X32nsrIjAzM8vNLq0OwMzMrBonKDMzy5ITlJmZZckJyszMsuQEZWZmWXKCMjOzLDlBmZlZlpygzMwsS05QNmFJmiPpKUl/2+pYcifpaEmrJG2Q9JikT0ma3Oq4Wk3SPElbJL2g1bG0Iycom8h6gR9GxLfLCyU9U9JWSSHp36ptKOm3kh4Y7wAlfUDStZLuKeK5b5j2u0g6R9JvJG2W9HtJl0rabQwxvBf4BvAwcA6wAng38MnR7rPO/sd8TJJeJOmLkn4tab2kgWJ/vZL+fLR9RsRy4L+Bj439SK1uEeHFS/YL8GLgDOAK4BRgCvA+0o/pY8BvgIPL2h8GBHBClX0dWdQ9BTwC7FJR/2fAVmB5E44rgDXAt4G1wH3DtP9ksc11xffRCzwJfK/yOEbY/1HFsS6qKP8G8ATwzCZ8B2M+JuCVRfuLgXcBbyv+rGwAHgL2GG2fwKlF29mt/nvQbkvLA/DiZSQLsD9wS/FD8TrgGuCQou5ZwB+B68raf74o66yyr4XFfpYU65dV1B9RlJ/fhOPau+y/bx8qQQGzi2Ty1Yry9xTxvrHOvncB7gB+Bqii7v3FPl8yzsff0GOqsv8FxX7OHW2fwFRgI3DFeP958LL94lN8tlOIiF+Tfjw2AW8B3hYRPy/q/kg6PbUOQNIkYB7w7Yh4ssru5hbrC0n/an5dRf0hxfrnDTyEqiLinjqavwEQcFlF+ZXAAPDmOrs/GjgAuDyKX+IyW4r1tDr3Wa9GH1Ol+4v19NH2GREbgJtIyc6aaFKrAzAbCUl7kE7zCfhYRKwrqzsGmAFcVBTNJf2r96c1dncIcH9E3CPpu8BJkv6h7Ee6lMB+ViOWXYr+RmptRGyto30tf0X6l/92xxURmyX9sqivx+uBQeAmSc+qqHt2sf5TtQ0b+B009JiKiR1Tgcmk5Fu6drRyjH3eDBwtab+I+E09MdnoOUHZzuIYUnL6VkT8oPgh+ivSj+w00um+R4q2BxTruyt3Imkq8ELg+qLoOuDVwF8DPynK5gIPR8TqGrE8D7i3jtifD9xXR/ta9gT+GBFPVKn7A/ASSc+IiC1V6qt5OdBBle+pTK0RXqO+g0Yf0+mka08l9wFvjoibxthn6TuaTbreaU3gBGU7i9cW66skfRw4nvRD0wn8F+kHsJSgdi/Wa6vs5yDStZfS6bvlwKdJp/l+UszieiHb/4u70mqgnqnrtRJdvbpIExeq2VzWZtgf82LE9DxgGfCvVZpcAzwREQ/V2EWjvoOGHVNhOSmBTAUOJv052b2izWj6XFOs9xhhHNYATlCWveKa0t+Sfjz+MyKuAc6VJOBE4P8C35F0QEQ8QLpWBWnEVal0+q50/eoxSTeREtS5pB+18gS2g4jYDHxnzAdWvwFq/0BOLmszEnsX61siYrtjkfR80jWbL9XauIHfQSOPiYh4EHiw+Lhc0leBWyRNiYiPjqHP0p8lv+G1iZygbGdwOOk03tcj4ukfjuKa0XWSXkmaWvwy4AukaedQ/RpJtQkQXwWukHQQw1x/ApDUwY7/Kh/KYxExWEf7Wh4CDpC0a5XTU/+DdNpqpCONqcW62jWm+cX6K7U2buB30Mhj2kFE3CbpF6Q/H6UENZo+S3+WHsOaxrP4bGdQOr339Rr1XcW6dBrm9mJd7e7/ateXlrFt+vpIZvA9lzRrcKTLc4fYVz1uIf2d/evywuJ63EHArXXs6/Fi/cyKfT0DeCdwJ7W/b2jcd9DIY6plCtv/Y2U0fe5brG+vUmfjxCMo2xkcT0ogKyorJO0PnExKKN8qin9B+gE+tKLtFGA/0k2oT4uIP0j6CSlBbQUeLU4V1dKqa1BfAf4P8A+kac8lZ5CS9Bfr2Fcf6TTW0aSbW0s+AuwFvHqYUV+jvoO6jklSJ7APMFCczi2Vz6o2qUXSy4E5wKrR9lk4FHgkIu6scRw2Hlp9I5YXL0MtpKnlQbreUXkz6TGkf52vAmZV1P0HaZLErmVlpadL9FTpZ1FRtxW4oYnHdwpwXrE8AvSXfT6lSvsr2PYEhNOBS0n3cq1ixycg3EdxJrRG36WnKXyB9ON8XfF5UaOOb4TfQT3HtFfRdlVF+TLgx6Rk+3bgbNK1yS2k++MOGkOfvlG3RUvLA/DipdZCenrEz0mPn3kB8EbS7LIbgB+QnhZxeI1t/7r4AXpdWdm7i7J5Vdo/v6gL4CNNPMZVZf1WLquqtO8A3ks6BfcEaVp0LzC1Sts/An8You9nkG5Wfaz4Af4v0sip2f+f6zmmWgnqZNIpyd+TJtNsIs3muwJ43hj7PK3oc06r/06026Lif4DZhCPpG8BuEfHSVsfSbJL+AvgV8PcR8R+tjmdnJulnpBu7T2p1LO3GkyRsInsvcJikV7U6kBY4mpSglrQ6kJ2ZpHnAgaQHE1uTeQRlZmZZ8gjKzMyy5ARlZmZZ8n1QDSDpKVKyf3y4tmZm9rRnAlsjomou8jWoBpC0FdC0aeP96hwzs4lj/fr1kO7Vq3o2zyOoxnh82rRp09atWzd8SzMzA6C7u5v169fXPPPka1BmZpYlJygzM8uSE5SZmWXJ16AsG/39sHQprF4Ns2bB/PkwfXqrozKzVnGCspaLgMWL4ZJLoKMDBgagqwvOOgsWLYKeHlC1d+Oa2YTmBGUtt3gx9PbC5s3byjZuTOve3rS+6KLmx2VmreX7oBpA0jpPMx+d/n7Yc8/tk1OlyZPh4Yehu7t5cZnZ+Cumma+PiKp/uz1Jwlpq6dJ0Wm8oHR1w7bXNicfM8uEEZS21enW65jSUgYHUzszaixOUtdSsWWlCxFC6ulI7M2svTlDWUvPnw+Dg0G0GB2HBgubEY2b5cIKylpo+PU0lrzWK6upK9Z4gYdZ+nKCs5Xp6YOFCmDQJOjtTWWdn+rxwYao3s/bj+6Cs5aR0n9OWLdDXBxs2wNSpMHu2738ya2dOUJaNKVNg7txWR2FmucjqFJ+kqZIul/SwpE2SbpV0/Ai2O13S1yTdX2x3V7Gf3au0jRrLO8bnqMzMbDRyG0EtAw4BzgXuBd4CLJN0XESsHGK7C4EbgQ8AfwAOAC4Ajpd0UERUPuLhK8BlFWX3jD18MzNrlGwSlKRjgKOAkyJiWVF2I7A3cCkwVII6OCIeLfv8fUl9wCrgFOCKivarI+LHjYrdzMwaL6dTfCcC64HrSwWRHhS4BNhP0gG1NqxITiW3FOvnNDJIMzNrjpwS1BygLyK2VpTfVlZfj1cU69ur1J1aXKvaLOknkk4eakeS1g21ANPqjM3MzIaRU4KaCaytUr62rH5EJM0ALgfuAq6pqP4icCbwKuBUYBPwFUln1xuwmZmNn2yuQRWGevfHiN4LIqkLWA7MAF4WEU9st5OIN1e0X0q6VvVhSZ+JiE07dFzjUfBl+/AoysyswXIaQa2h+ihpRrGuNrrajqQpwNeAg4FjIuK2YTahOKX4BWAq9Z9GNDOzcZJTgroD2F9SZUwHFutq15KeJmkyaYLFYcCxEfGjOvou9Vl5/cvMzFokpwS1DOgGjqsoPxW4MyL6am0oaVfSab2XAidExPdH2mmREN8E/ImUJM3MLAM5XYNaSbrZ9ipJM0k36p4GHA6cUGokaRVwRESobNulwNFAD7BB0qFldY9FxN3FtouAFwHfAx4GZgHvLPp4d0QM8eJxMzNrpmwSVESEpHnAxcXSDfSRbtxdMczmxxbrxcVSbgnpiRQAd5KS3bxi/xuBnwHHj6APMzNromwSFEBEPE6aAn7mEG2OrFKmKk2rbbsCcCKq0N8PS5em16rPmpVeIjh9equjMrN2l1WCsuaKgMWL4ZJLoKMDBgbSCwLPOiu9JLCnJ70Kw8ysFZyg2tjixdDbC5vLrrxt3JjWvb1p7fcxmVmr5DSLz5qovz+NnAYGqtcPDKT6dZXPgTczaxInqDa1dGk6rTeUjg649trmxGNmVskJqk2tXl179FQyMJDamZm1ghNUm5o1K02IGEpXV2pnZtYKTlBtav58GBwcus3gICxY0Jx4zMwqOUG1qenT01TyWqOorq5U3z3kc9zNzMaPE1Qb6+mBhQth0iTo7ExlnZ3p88KFqd7MrFV8H1Qbk9J9Tlu2QF8fbNgAU6fC7Nm+/8nMWs8JypgyBebObXUUZmbb8yk+MzPLkhOUmZllyQnKzMyy5ARlZmZZcoIyM7MsOUGZmVmWnKDMzCxLTlBmZpYlJygzM8uSE5SZmWXJCcrMzLLkBGVmZllygjIzsyxllaAkTZV0uaSHJW2SdKuk40ew3emSvibp/mK7u4r97F6j/VmSfivpCUl3SzpXUlbfhbVOfz9ceWV65ciVV6bPZtZ8uf0oLwPeBJwHvBboA5ZJOmaY7S4EHgc+ALwa6AVOBm6RtN07YSWdB3wC+DJwNHAV8BHg4sYdhu2MIuD882HPPeGcc+CCC9J6zz1TeUSrIzRrL9m8D6pIQkcBJ0XEsqLsRmBv4FJg5RCbHxwRj5Z9/r6kPmAVcApwRbG/mcAHgU9FxOKi7SpJuwHnSvpURDzYwMOyncjixdDbC5s3byvbuDGte3vT2i9yNGuenEZQJwLrgetLBRERwBJgP0kH1NqwIjmV3FKsn1NW9mpgcrHPcleTkvWwpxNtYurvh0sugYGB6vUDA6l+3brmxmXWznJKUHOAvojYWlF+W1l9PV5RrG+v6COAO8obRsRdwKZafUhaN9QCTKszNsvM0qXQ0TF0m44OuPba5sRjZnklqJnA2irla8vqR0TSDOBy4C7gmoo+BiLiiSqb9dfTh00sq1fXHj2VDAykdmbWHNlcgyoMdRl6RJeoJXUBy4EZwMuqJKO6+4iI7mrlZX16FLWTmzULurq2XXOqpqsrtTOz5shpBLWG6iOYGcW62uhqO5KmAF8DDgaOiYjbKpqsAXaTtGuVzaePpA+bmObPh8HBodsMDsKCBc2Jx8zySlB3APtXuR/pwGJ9O0OQNJk0weIw4NiI+FGNPgTMrth2X2DKcH3YxDV9OixalEZJ1XR1pfruIcfSZtZIOSWoZUA3cFxF+anAnRHRV2vDYkS0HHgpcEJEfL9G0xuAJ0hTz8udBjwFrBhF3DZB9PTAwoUwaRJ0dqayzs70eeHCVG9mzZPTNaiVwI3AVcX9SveSEsfhwAmlRpJWAUdEhMq2XUq66bYH2CDp0LK6xyLiboCIWCPpo8D5ktYX/R0GvA+4LCJ+P14HZ/mT0n1OW7ZAXx9s2ABTp8Ls2b7/yawVsklQERGS5pGe6HAxaTTVR7pxd7iRzbHFenGxlFsCvKXscw/pfqt3k5488RBwAfCxscRvE8eUKTB3bqujMLNsEhRARDwOnFkstdocWaVMVZrW2j6Ay4rFzMwyldM1KDMzs6c5QZmZWZacoMzMLEtOUGZmliUnKDMzy5ITlJmZZckJyszMsuQEZWZmWXKCMjOzLDlBmZlZlpygzMwsS05QZmaWJScoMzPLkhOUmZllyQnKzMyy5ARlZmZZcoIyM7MsOUGZmVmWnKDMzCxLTlBmZpYlJygzM8uSE5SZmWXJCcrMzLLkBGVmZlnKKkFJmirpckkPS9ok6VZJx49gu8MlfU7SLyU9KSlqtNtLUtRYXt34IzIzs9GaNJqNJL0QmA3sAQTwGHB7RNw1xniWAYcA5wL3Am8Blkk6LiJWDrHdK4EjgZ8DTwIvHqafy4CvVJT9ehTxmpnZOBlxgpK0P/AOYAHw7FJxsY6izSPANcC/R0RdP/iSjgGOAk6KiGVF2Y3A3sClwFAJ6qKIuLDY5jKGT1D3R8SP64nPzMyaa9gEJWkf4GPAicAm4CbgZuBuYA0pSc0A9gUOBU4H3iPpOuB9EXHPCGM5EVgPXF8qiIiQtAT4jKQDIqKv2oYRsXWEfZiZ2U5iJCOoPuC/SafbrouIjUM1lrQbMB84q9h28ghjmQP0VUk2t5XXj3Bfw/mgpI+TTgf+FPhwRHy3VmNJ64bZ37QGxWVmZoWRTJI4OSJeHBGfHy45AUTExohYEhFzgdfXEctMYG2V8rVl9WP1BHAl8E7gFaRTltOBb0s6sQH7NzOzBhl2BBUR1w/XpoHbVp19N4K6ke084mHgbWVFP5D0VeCXwD+TJmlU2657qP0WIyyPoszMGqjuaeaSTh6PQEjXs6qNkmYU62qjqzGLiAFgKbCPpN3How8zM6vfaO6D+pKktzc8ErgD2F9SZUwHFuvbx6HPklKfnmxhZpaJ0SSoq4F/lfTBapWSDpN00yj2uwzoBo6rKD8VuLPWDL6xktQFvA74XUSsGY8+zMysfnXfqBsRp0t6DLhI0rMi4hwASS8CPgqcQJqOXq+VwI3AVZJmkm7UPQ04vNgnRT+rgCMiQmVluwNHFB/3LcrmF5/vi4hbi7JLSUn5R6Sbi/cCziHdazVvFDGbmdk4GdWTJCLiA8VNuZcWyWED8PekiQz/DvSMYp8haR5wcbF0k6aVnxQRK4bZfDZwbUVZ6fMS0hR5SKcR305KfH9Guu/qZuBdEfHDemM2M7PxM6oEVbgSeC3wRlJi+jJwfh035u4gIh4HziyWWm2OrFK2im1PtRhq/58DPjfa+MzMrHlGM4uvU9LZpCdJvIL0/LsAOoHfNzY8MzNrV6OZJHEX0Eu6hnN8RLyYNIo6HlgpaWoD4zMzszY1mgTVAZwB/GVEfB0gIq4hJahDgRslPatxIZqZWTsazTWoF0TE5srCiPiWpKOAr5Nmyb1wrMGZmVn7qnsEVS05ldX9BHgpI39ArJmZWVUNf6Nu8R6ov2n0fs3MrL0Mm6AkvbLenUbE74ttjxpNUGZmZiMZQX1D0vckHSupY7jGxTT0EyV9n6HfgmtmZlbTSCZJHEyaVv414I+Svk16yd/dpCeMl96o+wLSLL5XFJ+/CRw0DjGbmVkbGMn7oG4HXiXpMOBdpOfivYEd388k4HHgOuDTEXFLg2OdkPr7YelSWL0aZs2C+fNh+vRWR2Vm1nojnmYeETcDNxen+eYCBwC7kxLVY6TXYfyiyivbrYoIWLwYLrkEOjpgYAC6uuCss2DRIujpAQ378CYzs4lrNE8zHySd4vtp48NpH4sXQ28vbC6btL9xY1r39qb1RRc1Py4zs1yMapq5pGdLeo+kSyVdKOmE4r1KNgL9/WnkNDBQvX5gINWvW9fcuMzMclL3CErSS0mz87rY/gniayRdFBGXNyq4iWrp0nRabygdHXDttXDGGc2JycwsN6MZQV1SrP8eeB7ppX9/R5rVd5mkLzUmtIlr9erao6eSgYHUzsysXY0mQc0BPhERSyLiwYh4ICKuiYhDSQ+Rfb2kmu9zsjRbr2uYE6JdXamdmVm7Gk2C+hPwQLWKiLiK9OLCd4wlqIlu/nwYHBy6zeAgLFjQnHjMzHI0mgR1I3DMMPX7jC6c9jB9eppKXmsU1dWV6ru7mxuXmVlORpOgPgO8pHirbjV7AQ+NOqI20dMDCxfCpEnQ2ZnKOjvT54ULU72ZWTsbzfugvgs8BfRKOhH4LPCzouwI4GzgfQ2LcIKS0n1OW7ZAXx9s2ABTp8Ls2b7/ycwMRpegLgL+kvScvZcVS/ljj34BrJM0B/hNRDw15ignsClTYO7cVkdhZpaf0TxJ4oLSf0vqJj1M9qBiORj4C+ALpKT1pKQ7gdsi4pSGRGxmZm1hNCOop0XEOtKkiBtLZZKeQZqKXkpYBwPHjaUfs3bkBwlbuxtTgqomIrYAPy8WM6uTHyRsljT8le9jIWmqpMslPSxpk6RbJR0/gu0Ol/Q5Sb+U9KSkyleBlLftLJ4feL+kJyTdIemtjT0Ss9Erf5Dwxo0pYW3cmD739qZ6s3aQVYIClgFvAs4DXgv0AcskDXXfFcArgSOB3wG/HKbtp4F/BC4DjgZuAD4ryTcXW8v5QcJm22SToIokdBRwekRcFRHfA04DbgYuHWbziyJi74iYD/xwiD5mA28FPhgRn4iIVRGxCPgScLGkyQ05GLNRqudBwmYTXTYJCjgRWA9cXyqIiACWAPtJOqDWhnW8JHEeaXbh5yvKrwamk15Xb9YyfpCw2TY5Jag5QF+VZHNbWX0j+lgdEX+spw9J64ZagGkNiM3MDxI2K5NTgpoJrK1Svrasfmfow2zU/CBhs21ySlCw/RMp6qkbax8xRB0R0T3UQjo1aTZmfpCw2TY5Jag1VB/BzCjW1UY+jeqjVNaIPszGxA8SNksafqPuGNwBvE7SLhXXoQ4s1rc3qI/XS5oZEWvGqQ+zMfGDhM2SnEZQy4Budnws0qnAnRHR14A+lgMC3lxRfhpQemyTWRZKDxI+4oi0nuybIKzN5DSCWklKEFdJmgncS0ochwMnlBpJWgUcEREqK9ud9KoPgH2LsvnF5/si4laAiLhd0tXARyWJ9OT1Y0kJ68yI2DRuR2dmZnXJJkFFREiaB1xcLN2kJ0mcFBErhtl8NlB562Lp8xLgLWXlbwceBBYCzwbuAd4WEVeO6QDMzKyhsklQABHxOHBmsdRqc2SVslWkU3cj6WMLcH6xmJlZpnK6BmVmZvY0JygzM8uSE5SZmWXJCcrMzLLkBGVmZllygjIzsyw5QZmZWZacoMzMLEtOUGZmliUnKDMzy5ITlJmZZckJyszMsuQEZWZmWXKCMjOzLDlBmZlZlpygzMwsS05QZmaWJScoMzPLkhOUmZllyQnKzMyy5ARlZmZZcoIyM7MsOUGZmVmWnKDMzCxLWSUoSVMlXS7pYUmbJN0q6fgRbruPpOWS1kv6k6SVkg6o0i5qLO9o/BGZmdloTWp1ABWWAYcA5wL3Am8Blkk6LiJW1tpI0h7ATcCjwGnAU8B5wPclHRwRD1Zs8hXgsoqyexpyBGZm1hDZJChJxwBHASdFxLKi7EZgb+BSoGaCAhYB04EXR8RDxbY3k5LcB4F3VrRfHRE/buwRmJlZI+V0iu9EYD1wfakgIgJYAuxX7XRdxbbfLiWnYts1wArgpPEJ18zMxlNOCWoO0BcRWyvKbyur34GkKcA+wO1Vqm8D9ihOAZY7tbjGtVnSTySdPFRgktYNtQDThj06MzOrS04Jaiawtkr52rL6aqYDqmPbLwJnAq8CTgU2AV+RdHa9AZuZ2fjJ5hpUIUZZN+JtI+LN5RWSlgKrgA9L+kxEbNph44juoTr2KMrMrPFyGkGtofooaUaxrjZCAugnJaDRbEtxSvELwFRqnEY0M7PmyylB3QHsL6kypgOLdbVrTBQjnnuonlwOBB6LiEeH6bvUZ+X1LzMza5GcEtQyoBs4rqL8VODOiOgbZtu/lTSrVCBpRrGv64bqtEiIbwL+REqSZmaWgZyuQa0EbgSukjSTdA/TacDhwAmlRpJWAUdEhMq2vQQ4BVgp6UK23aj7FHBx2baLgBcB3wMeBmaR7pE6HHh3RGwer4Mz21n198PSpbB6NcyaBfPnw/TprY7K2kE2CSoiQtI8UkK5mDSa6iPduLtimG0fkfRSUqL6PGlkeBPwsoh4oKzpnaRkN6/Y/0bgZ8Dxw/Vh1m4iYPFiuOQS6OiAgQHo6oKzzoJFi6CnB6Th92M2WtkkKICIeJw0BfzMIdocWaP8LspGWjXarCDdvGtmw1i8GHp7YXPZeYWNG9O6tzetL7qo+XFZ+8jpGpSZZaK/P42cBgaq1w8MpPp165obl7UXJygz28HSpem03lA6OuDaa5sTj7UnJygz28Hq1bVHTyUDA6md2XhxgjKzHcyalSZEDKWrK7UzGy9OUGa2g/nzYXBw6DaDg7BgQXPisfbkBGVmO5g+PU0lrzWK6upK9d1DPqXSbGycoMysqp4eWLgQJk2Czs5U1tmZPi9cmOrNxlNW90GZWT6kdJ/Tli3Q1wcbNsDUqTB7tu9/suZwgjKzIU2ZAnPntjoKa0c+xWdmZllygjIzsyw5QZmZWZacoMzMLEtOUGZmliUnKDMzy5ITlJmZZckJyszMsuQEZWZmWfKTJMxsp9Dfn16kuHp1es3H/PnpobY2cTlBmVnWImDx4vSK+Y6O9KLEri4466z0RPWenvTcQJt4nKDMLGuLF0NvL2zevK1s48a07u1Naz+8dmLyNSgzy1Z/fxo51Xr9/MBAql+3rrlxWXM4QZlZtpYuTaf1htLRAdde25x4rLl8is/MsrV6de3RU8nAQGrXDJ6o0VxZjaAkTZV0uaSHJW2SdKuk40e47T6SlktaL+lPklZKOqBG27Mk/VbSE5LulnSupKy+CzNLSaDWa+dLurpSu/EUAeefD3vuCeecAxdckNZ77pnKI8a3/0r9/XDllena25VXps+tMN5x5PajvAx4E3Ae8FqgD1gm6ZihNpK0B3ATsBdwGvAGYAbwfUnPqWh7HvAJ4MvA0cBVwEeAixt5IGY2dvPnw+Dg0G0GB2HBgvGNo3yixsaNKSFt3Jg+9/am+mbIJVE2K45sElSRhI4CTo+IqyLie6RkczNw6TCbLwKmA8dExPKI+E9SgtsV+GBZHzOLz5+KiMURsSoiLgY+Dry3MpmZWWtNn56mktcaRXV1pfru7vGLIaeJGrkkymbFkU2CAk4E1gPXlwoiIoAlwH61TteVbfvtiHiobNs1wArgpLJ2rwYmF/ssdzXpetyITieaWfP09MDChTBpEnR2prLOzvR54cJUP55ymaiRS6JsZhw5TZKYA/RFxNaK8tvK6ys3kjQF2Aeo9sfjNuCNkvaIiEeLfQRwR3mjiLhL0qaifgeShvuqpw1Tb2ajJKVrHFu2QF8fbNgAU6fC7NnNuf8pl4ka9STKM86YGHHklKBmAr+tUr62rL6a6YDK2tXa9tFiPRART6GfjHYAAAhgSURBVFRp2z9EH+PmyCOb3eOOcogBHEclx7G917wmLc1WmqhRujm4mmZM1MglUTYzjpwSFKTRzWjq6tm27j4iYsgz3MUIa1SjqBz+8ucQAziOSo5je62KY/789FiloTRjokYuibKZceR0DWoN1UcwM4p1tRESpJFPjHDbNcBuknat0nb6EH2YWZvKYaIG5DOjsZlx5JSg7gD2r3I/0oHF+vZqG0XEJuAeql8/OhB4rLj+VOpDwOzyRpL2BabU6sPM2ltposbkybDbbum62G67pc/NmKgB+STKZsaR0ym+ZcBbgeMom8kHnArcGRE7TJCo2PZMSbMiYjWApBnFvv5fWbsbgCeAU4Cfl5WfBjxFmvVnZrad0kSNhQu3f5LEggXjnxDKlRJh5ZPdBweblyibGYei2bdA1yBJwHeBvwDOBe4lJY5TgRMiYkXRbhVwRESobNtnA78CHgIuJCWb84AXAgdHxANlbS8Azgc+DNwIHAb0AJ+MiH8cZezrpk2bNm2dn1hpZk1Q+cilZifKRsXR3d3N+vXr19e6zp9NggKQ9EzSEx3mA92kaeU9EbG8rM0qKhJUUf4C4BLg5aRTlzcBiyLijop2As4G3g08j5TUPgN8rMoU95HG7QRlZlannSpB7aycoMzM6jdcgsppkoSZmdnTPIJqAElbAU2b5gdKmJmN1Pr16yE91a7qYMkJqgEkPUUajT7e6ljGoJRd17c0inz4+9iev49t/F1sbyzfxzOBrRFRdUa5E5QB2543ONxTM9qFv4/t+fvYxt/F9sbz+/A1KDMzy5ITlJmZZckJyszMsuQEZWZmWXKCMjOzLDlBmZlZlpygzMwsS74PyszMsuQRlJmZZckJyszMsuQEZWZmWXKCamOSXinpakl3ShqQ9KCk6yQd2OrYciHpQ5JC0i9bHUurSDpS0rckrSv+nPRJelur42o2SQdLWi7pIUkbi+/h/ZJ2bXVs40nScyR9UtIPJG0o/j4cWaPtGyX9StLm4vfknyRNHm3fTlDt7R2ktwp/AngNsLD4fIukQ1sZWA4kzQbeBzzS6lhaRdJpwHeAu4G/A44D/gV4RivjajZJ+wE/AvYC/oH0PVwHfAS4snWRNcW+wBuADcB3azWS9Gbgi8APSb8nF5PeXH71aDv2LL42JmmPiHi0oqwbuBf4XkS8rjWRtZ6kXUg/SLcABwLdEXFQa6NqLknPBe4EPhQRH291PK0k6UPABcC+EXF3WfnnSYm7KyKebFF440rSLhGxtfjvecAy4OURsaqsTQfwIPDTiDihrPwM4DPAoRHxk3r79giqjVUmp6JsHXAX8JzmR5SVc0jfwQdbHUgLvbVYX9HSKPJQSj6V7zxaX9QNNjec5iklp2EcCswCllSUf5H0/YzqH7tOULYdSbsDc4DbWx1Lq0jaG+gBzoyInfkllGP1MuDXwEnFdcrBsusKbXWKD/g8sBb4tKTnS3qmpBOA04BLR/gjPpHNKdbb/W5ExADp9PCcHbYYgapvMbT2JEmk4fguwCUtDqcliu/gSuCbEbG81fG02J7FcgVwPnAH8ArgA8BzgTe1LrTmiogHiuuyy4F7yqoujojzWxRWTmYW67VV6taW1dfFCcrK/TMwD/jfEfHrVgfTImcALwYOaHUgGdgF+DPgDRHx5aJslaQpwCJJF0TE71oXXvNI+p/ACmA1cCKwDjgC+ICkrU5ST6s1qWFUkx2coAwASR8B3gucHRFXtziclpD0LODjwEeBjcWEEUh/TzqKz5sjYnOrYmyyNcALgG9WlN8ALAIOAdoiQQH/RErWB0fEpqJsVRpws1jSVRFxX6uCy8CaYj2z7L9LZpAmXtXN16AMST3A/wHOjYjLWx1PCz0HmEZKUP1ly9+QzqH3Ax9qVXAt8N81ylWs2+m6y8FAX1lyKrmV9Du6X/NDysodxXq7a02SuoB9GOU1bSeoNifpAtL1hfMj4p9bHU+L/Q54eZXlV6QLvS8nXaNrF9cV62Mqyo8hnbK5pbnhtNRDwJziB7fcYcX6D02OJzc/Jp3+PKWi/A1AJ9v+LNXFp/jamKT3kkYE/wl8p+Lm3Cci4hctCaxFImIDsKqyXNK6on6HuoksIr4h6QbgX4rTn6VJEmcD/xYR97c0wOa6nHT/zzclXUaaXn4kcC7wnYioNdqcECTNL/7zr4r1EcWfiY0RcUNEPCXp/cDVkj4FLAX2Bz4GLI2IH4+qX9+o274krSJd6K3m/ojYq3nR5Kv4ntruRl0ASbsBF5L+Jbw78ADwWeDj7Ta1WtJRwPtJN25PBe4Dvgz0RsTGFoY27iTVShTb/U4UT5N4H/BC4I+k+6AuqHJqdGT9OkGZmVmOfA3KzMyy5ARlZmZZcoIyM7MsOUGZmVmWnKDMzCxLTlBmZpYlJygzM8uSE5SZmWXJCcrMzLLkBGVmZllygjKbYCRNKV7N/oCkXSvqPlu8uv3vWhWf2Ug5QZlNMMWDOS8gvZb9XaVySR8F3gq8p+wNuWbZ8sNizSYgSR2k91jtAewNnA58gvRk6Z5WxmY2Uk5QZhOUpGOBFcB3Se9x+lREnNXaqMxGzgnKbAKT9DPgENJ7i94Y/gtvOxFfgzKboCSdDJResvgnJyfb2XgEZTYBSXoV6fTeCuBJYAFwYET8uqWBmdXBCcpsgpH0v0jXnX4KvAZ4DvBrYGVEzGtlbGb18Ck+swlE0v7A14HfAvMi4omIuBu4CjhB0t+0NECzOngEZTZBSHoe8ENgC/CSiHikrO7PgbuBX0SEk5TtFJygzMwsSz7FZ2ZmWXKCMjOzLDlBmZlZlpygzMwsS05QZmaWJScoMzPLkhOUmZllyQnKzMyy5ARlZmZZcoIyM7Ms/X/idsIEcXd7QQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_binom_pdf(10, 0.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question\n",
    "+ Start increasing $N$. Try really big numbers. Does the result remind you a familiar distribution?\n",
    "\n",
    "+ Play a little bit with $\\theta$. What happens as you move it around?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The central limit theorem (CLT)\n",
    "Consider, $X_1,X_2,\\dots$ be iid random variables with mean $\\mu$ and variance $\\sigma^2$.\n",
    "Define their sum:\n",
    "$$\n",
    "S_N = \\frac{X_1+\\dots+X_N}{N}.\n",
    "$$\n",
    "The Central Limit Theorem (CLT), states that:\n",
    "$$\n",
    "S_N \\sim \\mathcal{N}(S_N|\\mu, \\frac{\\sigma^2}{N}),\n",
    "$$\n",
    "for large $N$.\n",
    "That is, they start to look like Gaussian.\n",
    "Let's test it for the Exponential distribution.\n",
    "We will use ``numpy.random.exponential`` to sample from the exponential."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1a24ad5fd0>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "r = 0.5\n",
    "N = 5   # How many iid variables are we going to sum\n",
    "M = 10000 # How many times do you want to sample\n",
    "Ts = np.random.exponential(scale=1./r, size=(N, M))  # Notice that it uses the inverse of the rate.\n",
    "                                                     # It is always a good idea to look at the documentation\n",
    "                                                     # if you are unsure.\n",
    "# These are the samples of SN:\n",
    "SN = np.sum(Ts, axis=0) / N  # Notice that I am only summing the rows\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "ax.hist(SN, bins=100, density=True, alpha=0.5, label='Empirical histogram of $S_N$')\n",
    "mu_CLT = 1. / r             # CLT mean\n",
    "sigma_CLT = np.sqrt(1. / (N * r**2)) # CLT standard deviation\n",
    "Ss = np.linspace(SN.min(), SN.max(), 100)\n",
    "ax.plot(Ss, st.norm(loc=mu_CLT, scale=sigma_CLT).pdf(Ss), label='CLT Gaussian')\n",
    "ax.set_xlabel('$S_N$')\n",
    "ax.set_ylabel('$p(S_N)$')\n",
    "ax.set_title('CLT: Exponential by Gaussian (N=%d)' % N)\n",
    "plt.legend(loc='best')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Questions\n",
    "\n",
    "+ Start increase $N$ and observe the convergence.\n",
    "+ Go back to the Bernoulli distribution. What are its mean and variance? What is the mean and the variance of the Gaussian approximating the sum of idenpdent Bernoulli distributions? Verify this result numerically (copy paste the code above and make the appropriate changes)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A simple proof of the central limit theorem\n",
    "\n",
    "The proof of the CLT is surprisingly simple.\n",
    "It goes as follows:\n",
    "+ Take the [Fourier transform](https://en.wikipedia.org/wiki/Fourier_transform) of the PDF of\n",
    "$$\n",
    "Z_N = \\frac{X_1 + \\dots + X_N - N\\mu}{\\sqrt{N}\\sigma}.\n",
    "$$\n",
    "+ Take the limit of $N\\rightarrow +\\infty$.\n",
    "+ Compare what you find to the Fourier transform of the PDF of the standard normal $Z\\sim N(0,1)$.\n",
    "\n",
    "Note: The Fourier transform of the PDF of a random variable is called the [characteristic function](https://en.wikipedia.org/wiki/Characteristic_function_(probability_theory)) of the random variable.\n",
    "\n",
    "Ok, let's start with the PDF of the standard normal $Z\\sim N(0,1)$ so that we know what we should expect to find.\n",
    "The PDF of the standard normal is:\n",
    "$$\n",
    "\\phi(z) = \\frac{1}{\\sqrt{2\\pi}}\\exp\\left\\{-\\frac{z^2}{2}\\right\\}.\n",
    "$$\n",
    "We have (we just looked it up in Fourier transform table):\n",
    "$$\n",
    "\\hat{\\phi}(t) = \\int_{-\\infty}^{+\\infty} e^{itz}\\phi(z)dz \\equiv \\mathbb{E}\\left[e^{itZ}\\right] = e^{-\\frac{t^2}{2}}.\n",
    "$$\n",
    "Notice that the Fourier transform is nothing more than an expectation.\n",
    "This notation is very convenient.\n",
    "\n",
    "Now, let's work on the fourier transform of the PDF of $S_N$:\n",
    "$$\n",
    "\\begin{split}\n",
    "\\hat{p}_{Z_N}(t) &=& \\mathbb{E}\\left[e^{tZ_N}\\right]\\;\\text{(definition)}\\\\\n",
    "&=& \\mathbb{E}\\left[e^{t\\frac{X_1+\\dots+X_N-N\\mu}{\\sqrt{N}\\sigma}}\\right]\\;\\text{(definition)}\\\\\n",
    "&=& \\prod_{n=1}^N \\mathbb{E}\\left[e^{t\\frac{X_n-\\mu}{\\sqrt{N}\\sigma}}\\right]\\;\\text{(independent r.v.)}\\\\\n",
    "&=& \\prod_{n=1}^N \\hat{p}_{Y_n}\\left(\\frac{t}{\\sqrt{N}}\\right);\\text{(FT definition)}\\\\\n",
    "&=& \\left[\\hat{p}_{Y_1}\\left(\\frac{t}{\\sqrt{N}}\\right)\\right]^N\\;\\text{(identical dist. r.v.)}\\\\\n",
    "&=& \\left[\\hat{p}_{Y_1}(0) + \\frac{t}{\\sqrt{N}}\\hat{p}_{Y_1}'(0) + \\frac{t^2}{2N}\\hat{p}_{Y_1}''(0) + \\dots\\right]^N\\;\\text{(Taylor expansion)}\\\\\n",
    "&=& \\left[1 + \\frac{t}{\\sqrt{N}}\\cdot 0 + \\frac{t^2}{2N}\\cdot(-1) + \\dots\\right]^N\\;\\text{(see below)}\\\\\n",
    "&=& \\left[1 - \\frac{t^2}{2N} + \\dots\\right]^N\n",
    "\\end{split}\n",
    "$$\n",
    "where we have defined the centered and normalized random variables:\n",
    "$$\n",
    "Y_n = \\frac{X_n - \\mu}{\\sigma},\n",
    "$$\n",
    "and we used the fact that:\n",
    "$$\n",
    "\\hat{p}_{Y_n}(0) = \\mathbb{E}\\left[e^{itY_n}\\right]|_{t=0} = 1,\n",
    "$$\n",
    "$$\n",
    "\\hat{p}_{Y_n}'(0) = \\left\\{\\mathbb{E}\\left[e^{itY_n}\\right]\\right\\}'|_{t=0} = \\mathbb{E}\\left[iY_ne^{itY_n}\\right]|_{t=0} = i \\mathbb{E}[Y_n] = 0,\n",
    "$$\n",
    "and\n",
    "$$\n",
    "\\begin{split}\n",
    "\\hat{p}_{Y_n}''(0) &=& \\left\\{\\mathbb{E}\\left[e^{itY_n}\\right]\\right\\}''|_{t=0}\\\\\n",
    "&=& \\left\\{\\mathbb{E}\\left[iY_ne^{itY_n}\\right]\\right\\}'|_{t=0}\\\\\n",
    "&=& \\left\\{\\mathbb{E}\\left[i^2Y_n^2e^{itY_n}\\right]\\right\\}'|_{t=0}\\\\\n",
    "&=& -\\mathbb{E}[Y_n^2]\\\\\n",
    "&=& -1.\n",
    "\\end{split}\n",
    "$$\n",
    "\n",
    "Finally, we can take the limit $N\\rightarrow+\\infty$ to get:\n",
    "$$\n",
    "\\hat{p}_{Z_N}(t) = \\left[1 - \\frac{t^2}{2N} + \\dots\\right]^N\\rightarrow e^{-\\frac{t^2}{2}}.\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inverse sampling\n",
    "How do you sample an arbitrary univariate continuous random variable $X$ with CDF $F(x)$.\n",
    "In this scenario, *inverse sampling* is the way to go.\n",
    "It relies on the observation that the random variable\n",
    "$$\n",
    "Y = F^{-1}(U),\n",
    "$$\n",
    "where $F^{-1}$ is the inverse of the CDF of $X$ and $U\\sim\\mathcal{U}([0,1])$ has exactly the same distribution as $X$.\n",
    "\n",
    "We will demonstrate this by example. To this end, let us consider an [exponential random variable](https://en.wikipedia.org/wiki/Exponential_distribution):\n",
    "$$\n",
    "T \\sim E(r),\n",
    "$$\n",
    "where $r > 0$ is known as the *rate parameter*.\n",
    "The exponential distribution describes the time it passes between random events that occur at a constnat rate $r$.\n",
    "Its PDF is:\n",
    "$$\n",
    "p(t) = re^{-rt},\n",
    "$$\n",
    "and its CDF is:\n",
    "$$\n",
    "F(t) = p(T\\le t) = 1 - e^{-rt}.\n",
    "$$\n",
    "We plot it next."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "r = .5 # Events occur every 0.5 minutes\n",
    "fig, ax = plt.subplots()\n",
    "t = np.linspace(0., 5. / r, 100)\n",
    "ax.plot(t, st.expon(scale=1./r).cdf(t))\n",
    "ax.set_xlabel('$t$')\n",
    "ax.set_ylabel(r'$F(t) = p(T <= t)$')\n",
    "ax.set_title(r'$T\\sim E(r=%.2f)$' % r);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To sample $T$ using inverse sampling, we need the inverse of the CDF. This is easily shown to be:\n",
    "$$\n",
    "F^{-1}(u) = -\\frac{\\ln(1-u)}{r}.\n",
    "$$\n",
    "Let's see if this is going to give us the right samples.\n",
    "We will compare the empirical histogram obtained by inverse sampling to the actual PDF $p(t)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1a24d22b90>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def sample_exp(r):\n",
    "    u = np.random.rand()\n",
    "    return -np.log(1. - u) / r\n",
    "\n",
    "N = 10000\n",
    "T = [sample_exp(r) for _ in range(N)]\n",
    "fig, ax = plt.subplots()\n",
    "ax.hist(T, alpha=0.5, density=True, bins=100, label='Histogram of samples')\n",
    "ax.plot(t, st.expon(scale=1./r).pdf(t))\n",
    "ax.set_xlabel('$t$')\n",
    "ax.set_ylabel('$p(t)')\n",
    "ax.set_title(r'$T\\sim\\mathcal{E}(r=%.2f)$' % r)\n",
    "plt.legend(loc='best')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Questions\n",
    "\n",
    "+ Implement inverse sampling for a univariate Gaussian with zero mean and unit variance. Use ``scipy.stats`` to find the inverse CDF of the Gaussian (It is ``st.norm.ippf``)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Rejection sampling\n",
    "\n",
    "Rejection sampling is a method that allows us to sample from a PDF of a scalar random variable even if we do not know its normalization constant.\n",
    "That is, we can use it to sample from a PDF of the form:\n",
    "$$\n",
    "p(x) = \\frac{\\pi(x)}{Z},\n",
    "$$\n",
    "where $Z$ is not explicitly known.\n",
    "How does it work?\n",
    "The basic ingredient is another PDF, say $q(x)$, for each we can show that:\n",
    "$$\n",
    "M q(x) \\ge \\pi(x),\n",
    "$$\n",
    "for some constant $M$ and from which we can easily sample.\n",
    "Instead of introducing the method theoretically, let's introduce it via an specific example.\n",
    "\n",
    "### Example: Using rejection sampling to sample from the beta distribution\n",
    "\n",
    "The PDF of the Beta is:\n",
    "$$\n",
    "p(x) \\propto x^{\\alpha-1}(1-x)^{\\beta - 1}1_{[0,1]}(x),\n",
    "$$\n",
    "for some $\\alpha$ and $\\beta$ positive.\n",
    "Of course, in this case, we do know the normalization constant but let's pretend that we don't know it.\n",
    "We need to find a PDF $q(x)$ from which we can easily sample and a constant $M$ so that the inequality we introduced above is satisfied.\n",
    "Let's take the PDF of the uniform:\n",
    "$$\n",
    "q(x) = 1_{[0,1]}(x).\n",
    "$$\n",
    "How can we find the desired constant.\n",
    "We want to have:\n",
    "$$\n",
    "\\begin{split}\n",
    "M q(x) &\\ge& \\pi(x)\\\\\n",
    "M &\\ge& \\frac{\\pi(x)}{q(x)}\\\\\n",
    "M &\\ge& x^{\\alpha-1}(1-x)^{\\beta - 1}1_{[0,1](x)} = h(x).\n",
    "\\end{split}\n",
    "$$\n",
    "So, $M=1$ always works because $x$ is in $[0,1]$.\n",
    "We can also find a smaller $M$ by using a little bit of calculus, but we are not going to bother.\n",
    "\n",
    "Alright. Nothing so far.\n",
    "You will see the idea of rejection sampling once we draw the following graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am using M = 0.15\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "a = 2.0\n",
    "b = 3.0\n",
    "pi = lambda x: x ** (a - 1.0) * (1.0 - x) ** (b - 1.0)\n",
    "q = lambda x: np.ones_like(x)\n",
    "xs = np.linspace(0, 1, 100)\n",
    "M = np.max(pi(xs))\n",
    "print('I am using M = {0:1.2f}'.format(M))\n",
    "fig, ax = plt.subplots()\n",
    "ax.plot(xs, pi(xs), label='$\\pi(x)$')\n",
    "ax.plot(xs, M * q(xs), label='$M\\cdot q(x)$')\n",
    "# Let's also color the region between \n",
    "ax.fill_between(xs, pi(xs), M * q(xs), alpha=0.25)\n",
    "plt.legend(loc='best');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is the idea:\n",
    "+ We sample a point inside the area specified by $M\\cdot q(x)$.\n",
    "+ If we hit the white area, we keep the sample and go to the next step\n",
    "Otherwise, we reject the sample, and go to the first step.\n",
    "+ The $x$-coordinate of the accepted sample is a sample from $p(x)$.\n",
    "\n",
    "Let's try it out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Number of samples to take:\n",
    "num_samples = 1000\n",
    "# An array to store the samples\n",
    "x_rs = np.ndarray((num_samples,))\n",
    "# Start sampling\n",
    "for n in range(num_samples):\n",
    "    # Keep sampling until a sample is accepted\n",
    "    while True:\n",
    "        # Sample a point in the 2D domain defined by M * q(x)\n",
    "        # x coordinate comes by sampling q(x) (which is uniform here)\n",
    "        x_c = np.random.rand()\n",
    "        # y coordinate comes by sampling a number between 0 and M * q(x_c)\n",
    "        y_c = M * q(x_c) * np.random.rand()\n",
    "        # Test if we are above or below pi(x_c)\n",
    "        if y_c <= pi(x_c):\n",
    "            # The sample is accepted, break the loop\n",
    "            break\n",
    "        # The sample is rejected. The loop will be repeated.\n",
    "    x_rs[n] = x_c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1a23dcb2d0>]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Let's plot the hist of the samples we just got and compare it to the PDF of the Beta\n",
    "fig, ax = plt.subplots()\n",
    "ax.hist(x_rs, density=True, alpha=0.25)\n",
    "ax.plot(xs, st.beta(a, b).pdf(xs))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Questions\n",
    "\n",
    "+ Rerun the rejection sampling algorithm above for different $\\alpha$ and $\\beta$."
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  },
  "latex_envs": {
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 0
  },
  "widgets": {
   "state": {
    "968a18c908c6495081a9936faebe0473": {
     "views": [
      {
       "cell_index": 11
      }
     ]
    }
   },
   "version": "1.2.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
